#ifndef _Path_h
#define _Path_h

#include "CxxUtils.h"
#include "LangUtils.h"

class DoOpPath
{
public: 
	class ds_newpath : public _DoOperator
	{
	protected: 
		ds_newpath(const ds_newpath &);
		ds_newpath& operator=(const ds_newpath &);
	public: 
		ds_newpath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_currentpoint : public _DoOperator
	{
	protected: 
		ds_currentpoint(const ds_currentpoint &);
		ds_currentpoint& operator=(const ds_currentpoint &);
	public: 
		ds_currentpoint() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_moveto : public _DoOperator
	{
	protected: 
		ds_moveto(const ds_moveto &);
		ds_moveto& operator=(const ds_moveto &);
	public: 
		ds_moveto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rmoveto : public _DoOperator
	{
	protected: 
		ds_rmoveto(const ds_rmoveto &);
		ds_rmoveto& operator=(const ds_rmoveto &);
	public: 
		ds_rmoveto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_lineto : public _DoOperator
	{
	protected: 
		ds_lineto(const ds_lineto &);
		ds_lineto& operator=(const ds_lineto &);
	public: 
		ds_lineto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rlineto : public _DoOperator
	{
	protected: 
		ds_rlineto(const ds_rlineto &);
		ds_rlineto& operator=(const ds_rlineto &);
	public: 
		ds_rlineto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_arc : public _DoOperator
	{
	protected: 
		ds_arc(const ds_arc &);
		ds_arc& operator=(const ds_arc &);
	public: 
		ds_arc() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_arcn : public _DoOperator
	{
	protected: 
		ds_arcn(const ds_arcn &);
		ds_arcn& operator=(const ds_arcn &);
	public: 
		ds_arcn() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_arct : public _DoOperator
	{
	protected: 
		ds_arct(const ds_arct &);
		ds_arct& operator=(const ds_arct &);
	public: 
		ds_arct() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_arcto : public _DoOperator
	{
	protected: 
		ds_arcto(const ds_arcto &);
		ds_arcto& operator=(const ds_arcto &);
	public: 
		ds_arcto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_curveto : public _DoOperator
	{
	protected: 
		ds_curveto(const ds_curveto &);
		ds_curveto& operator=(const ds_curveto &);
	public: 
		ds_curveto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rcurveto : public _DoOperator
	{
	protected: 
		ds_rcurveto(const ds_rcurveto &);
		ds_rcurveto& operator=(const ds_rcurveto &);
	public: 
		ds_rcurveto() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_closepath : public _DoOperator
	{
	protected: 
		ds_closepath(const ds_closepath &);
		ds_closepath& operator=(const ds_closepath &);
	public: 
		ds_closepath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_flattenpath : public _DoOperator
	{
	protected: 
		ds_flattenpath(const ds_flattenpath &);
		ds_flattenpath& operator=(const ds_flattenpath &);
	public: 
		ds_flattenpath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_reversepath : public _DoOperator
	{
	protected: 
		ds_reversepath(const ds_reversepath &);
		ds_reversepath& operator=(const ds_reversepath &);
	public: 
		ds_reversepath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_strokepath : public _DoOperator
	{
	protected: 
		ds_strokepath(const ds_strokepath &);
		ds_strokepath& operator=(const ds_strokepath &);
	public: 
		ds_strokepath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_ustrokepath : public _DoOperator
	{
	protected: 
		ds_ustrokepath(const ds_ustrokepath &);
		ds_ustrokepath& operator=(const ds_ustrokepath &);
	public: 
		ds_ustrokepath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_charpath : public _DoOperator
	{
	protected: 
		ds_charpath(const ds_charpath &);
		ds_charpath& operator=(const ds_charpath &);
	public: 
		ds_charpath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_uappend : public _DoOperator
	{
	protected: 
		ds_uappend(const ds_uappend &);
		ds_uappend& operator=(const ds_uappend &);
	public: 
		ds_uappend() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_clippath : public _DoOperator
	{
	protected: 
		ds_clippath(const ds_clippath &);
		ds_clippath& operator=(const ds_clippath &);
	public: 
		ds_clippath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_setbbox : public _DoOperator
	{
	protected: 
		ds_setbbox(const ds_setbbox &);
		ds_setbbox& operator=(const ds_setbbox &);
	public: 
		ds_setbbox() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_pathbbox : public _DoOperator
	{
	protected: 
		ds_pathbbox(const ds_pathbbox &);
		ds_pathbbox& operator=(const ds_pathbbox &);
	public: 
		ds_pathbbox() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_pathforall : public _DoOperator
	{
	protected: 
		ds_pathforall(const ds_pathforall &);
		ds_pathforall& operator=(const ds_pathforall &);
	public: 
		ds_pathforall() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_upath : public _DoOperator
	{
	protected: 
		ds_upath(const ds_upath &);
		ds_upath& operator=(const ds_upath &);
	public: 
		ds_upath() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_initclip : public _DoOperator
	{
	protected: 
		ds_initclip(const ds_initclip &);
		ds_initclip& operator=(const ds_initclip &);
	public: 
		ds_initclip() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_clip : public _DoOperator
	{
	protected: 
		ds_clip(const ds_clip &);
		ds_clip& operator=(const ds_clip &);
	public: 
		ds_clip() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_eoclip : public _DoOperator
	{
	protected: 
		ds_eoclip(const ds_eoclip &);
		ds_eoclip& operator=(const ds_eoclip &);
	public: 
		ds_eoclip() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rectclip : public _DoOperator
	{
	protected: 
		ds_rectclip(const ds_rectclip &);
		ds_rectclip& operator=(const ds_rectclip &);
	public: 
		ds_rectclip() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_ucache : public _DoOperator
	{
	protected: 
		ds_ucache(const ds_ucache &);
		ds_ucache& operator=(const ds_ucache &);
	public: 
		ds_ucache() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	static void push(_DoDictionaryMultimap& dict) {
		dict.put(CRefPtr< _DoObject >(new DoName("newpath")), CRefPtr< _DoObject >(new ds_newpath()));
		dict.put(CRefPtr< _DoObject >(new DoName("currentpoint")), CRefPtr< _DoObject >(new ds_currentpoint()));
		dict.put(CRefPtr< _DoObject >(new DoName("moveto")), CRefPtr< _DoObject >(new ds_moveto()));
		dict.put(CRefPtr< _DoObject >(new DoName("rmoveto")), CRefPtr< _DoObject >(new ds_rmoveto()));
		dict.put(CRefPtr< _DoObject >(new DoName("lineto")), CRefPtr< _DoObject >(new ds_lineto()));
		dict.put(CRefPtr< _DoObject >(new DoName("rlineto")), CRefPtr< _DoObject >(new ds_rlineto()));
		dict.put(CRefPtr< _DoObject >(new DoName("arc")), CRefPtr< _DoObject >(new ds_arc()));
		dict.put(CRefPtr< _DoObject >(new DoName("arcn")), CRefPtr< _DoObject >(new ds_arcn()));
		dict.put(CRefPtr< _DoObject >(new DoName("arct")), CRefPtr< _DoObject >(new ds_arct()));
		dict.put(CRefPtr< _DoObject >(new DoName("arcto")), CRefPtr< _DoObject >(new ds_arcto()));
		dict.put(CRefPtr< _DoObject >(new DoName("curveto")), CRefPtr< _DoObject >(new ds_curveto()));
		dict.put(CRefPtr< _DoObject >(new DoName("rcurveto")), CRefPtr< _DoObject >(new ds_rcurveto()));
		dict.put(CRefPtr< _DoObject >(new DoName("closepath")), CRefPtr< _DoObject >(new ds_closepath()));
		dict.put(CRefPtr< _DoObject >(new DoName("flattenpath")), CRefPtr< _DoObject >(new ds_flattenpath()));
		dict.put(CRefPtr< _DoObject >(new DoName("reversepath")), CRefPtr< _DoObject >(new ds_reversepath()));
		dict.put(CRefPtr< _DoObject >(new DoName("strokepath")), CRefPtr< _DoObject >(new ds_strokepath()));
		dict.put(CRefPtr< _DoObject >(new DoName("ustrokepath")), CRefPtr< _DoObject >(new ds_ustrokepath()));
		dict.put(CRefPtr< _DoObject >(new DoName("charpath")), CRefPtr< _DoObject >(new ds_charpath()));
		dict.put(CRefPtr< _DoObject >(new DoName("uappend")), CRefPtr< _DoObject >(new ds_uappend()));
		dict.put(CRefPtr< _DoObject >(new DoName("clippath")), CRefPtr< _DoObject >(new ds_clippath()));
		dict.put(CRefPtr< _DoObject >(new DoName("setbbox")), CRefPtr< _DoObject >(new ds_setbbox()));
		dict.put(CRefPtr< _DoObject >(new DoName("pathbbox")), CRefPtr< _DoObject >(new ds_pathbbox()));
		dict.put(CRefPtr< _DoObject >(new DoName("pathforall")), CRefPtr< _DoObject >(new ds_pathforall()));
		dict.put(CRefPtr< _DoObject >(new DoName("upath")), CRefPtr< _DoObject >(new ds_upath()));
		dict.put(CRefPtr< _DoObject >(new DoName("initclip")), CRefPtr< _DoObject >(new ds_initclip()));
		dict.put(CRefPtr< _DoObject >(new DoName("clip")), CRefPtr< _DoObject >(new ds_clip()));
		dict.put(CRefPtr< _DoObject >(new DoName("eoclip")), CRefPtr< _DoObject >(new ds_eoclip()));
		dict.put(CRefPtr< _DoObject >(new DoName("rectclip")), CRefPtr< _DoObject >(new ds_rectclip()));
		dict.put(CRefPtr< _DoObject >(new DoName("ucache")), CRefPtr< _DoObject >(new ds_ucache()));
	}
};

#endif
